package thread3;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

// 实现Callable接口
class Demo implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println("come in Callable");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1024;
    }
}

// 实现Runnable接口
class Demo2 implements Runnable {
    @Override
    public void run() {
        System.out.println("come in Runnable");
    }
}

public class CallableDemo {
    public static void main(String[] args) throws InterruptedException {
        // 声明一个FutureTask接口才可以执行实现Callable接口的类
        // FutureTask可以复用，如果有多个线程调用了futureTask，只会执行一次，如果要执行多次，那么就需要声明多个FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(new Demo());
        Thread thread = new Thread(futureTask, "a");
        thread.start();

        // 如果a线程没有运行完，那么就等着
        while (!futureTask.isDone()) {
            // Callable可以获取到返回值，但是Runnable没有办法获取到返回值
            // 两个线程：一个main线程，一个a线程，
            try {
                int result01 = 123;
                // 如无必要，建议放到最后，要求获得a线程的运行结果，
                // 如果没有获取到，就会阻塞线程，直到获取到结果，所以放到最后，可以防止线程阻塞
                System.out.println(futureTask.get() + result01);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }

//        Demo2 demo2 = new Demo2();
//        Thread thread1 = new Thread(demo2);
//        thread1.start();
    }
}
